package meituan.summer10;

/**
 * @Author Fizz Pu
 * @Date 2021/4/14 下午4:35
 * @Version 1.0
 * 失之毫厘，缪之千里！
 */
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.*;

// 贪心的思路, 先将数组排序, n从1开始递增, 每次做差即可
// 我的思路竟然是把1-n的全排列i求出来, 然后做差, 最后选取最小的.
// 贪心就要敢猜测, 先提交一把试试.
/*
我们称一个长度为n的序列为正则序列，当且仅当该序列是一个由1~n组成的排列，即该序列由n个正整数组成，取值在[1,n]范围，且不存在重复的数，同时正则序列不要求排序

有一天小团得到了一个长度为n的任意序列，他需要在有限次操作内，将这个序列变成一个正则序列，每次操作他可以任选序列中的一个数字，并将该数字加一或者减一。

请问他最少用多少次操作可以把这个序列变成正则序列？


输入描述:
输入第一行仅包含一个正整数n，表示任意序列的长度。(1<=n<=20000)

输入第二行包含n个整数，表示给出的序列，每个数的绝对值都小于10000。


输出描述:
输出仅包含一个整数，表示最少的操作数量。


输入例子1:
5
-1 2 3 10 100

输出例子1:
103



 */
public class Main2 {
    public static void main(String[] args) throws IOException {
       /* BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine().trim());
        String[] strSeq = br.readLine().trim().split(" ");
        int[] seq = new int[n];
        for(int i = 0; i < n; i++) seq[i] = Integer.parseInt(strSeq[i]);
        Arrays.sort(seq);
        int modifyTimes = 0;
        for(int i = 1; i <= n; i++) modifyTimes += Math.abs(seq[i - 1] - i);
        System.out.println(modifyTimes);*/
        List<Integer> arr = List.of(2,3,1,1);
        LinkedList<Integer> list  = new LinkedList<>(arr);
        list.sort((o1, o2) -> {
            return o1.compareTo(o2);
        });
        list.stream().sorted( (o1,o2) ->  o1.compareTo(o2));
        Collections.reverseOrder();
        list.forEach( System.out::println );
    }


    /*public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] arr = new int[n];
        for(int i = 0; i < n; i++){
            arr[i] = scanner.nextInt();
        }
        System.out.println(new Main().getMinOperationNum(n, arr));
    }

    public int getMinOperationNum(int n, int[] arr){
        int[] tmp = new int[n];
        for(int i = 1; i <= n; i++){
            tmp[i-1] = i;
        }
        List<List<Integer>> nums = permute(tmp);
        int cost = Integer.MAX_VALUE;
        for(List<Integer> num : nums){
            int sum = 0;
            for(int i = 0; i < n; i++){
                sum += Math.abs(num.get(i) - arr[i]);
            }
            cost = Math.min(cost, sum);
        }
        return cost;
    }

    public List<List<Integer>> permute(int[] nums) {

        List<List<Integer>> res = new ArrayList<>();
        int[] visited = new int[nums.length];
        backtrack(res, nums, new ArrayList<Integer>(), visited);
        return res;
    }

    private void backtrack(List<List<Integer>> res, int[] nums, ArrayList<Integer> tmp, int[] visited) {
        if (tmp.size() == nums.length) {
            res.add(new ArrayList<>(tmp));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (visited[i] == 1) continue;
            visited[i] = 1;
            tmp.add(nums[i]);
            backtrack(res, nums, tmp, visited);
            visited[i] = 0;
            tmp.remove(tmp.size() - 1);
        }
    }*/
}

